home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / telecomm / sticpsrc.lzh / SOURCE.ARC / FTP.C < prev    next >
C/C++ Source or Header  |  1990-03-03  |  4KB  |  177 lines
  1. /* Stuff common to both the FTP server and client */
  2. #include <stdio.h>
  3. #include "global.h"
  4. #include "mbuf.h"
  5. #include "netuser.h"
  6. #include "timer.h"
  7. #include "tcp.h"
  8. #include "ftp.h"
  9. #include "session.h"
  10.  
  11. /* FTP Data channel Receive upcall handler */
  12. void
  13. ftpdr(tcb,cnt)
  14. struct tcb *tcb;
  15. int16 cnt;
  16. {
  17.     register struct ftp *ftp;
  18.     struct mbuf *bp;
  19.     char c;
  20.  
  21.     ftp = (struct ftp *)tcb->user;
  22.     if(ftp->state != RECEIVING_STATE){
  23.         close_tcp(tcb);
  24.         return;
  25.     }
  26.     /* This will likely also generate an ACK with window rotation */
  27.     recv_tcp(tcb,&bp,cnt);
  28.  
  29. #if (defined(UNIX) || defined(MAC) || defined(AMIGA) || defined(ATARI_ST) || defined(MSC))
  30.     if(ftp->type == ASCII_TYPE){
  31.         while(pullup(&bp,&c,1) == 1){
  32.             if(c != '\r')
  33.                 putc(c,ftp->fp);
  34.         }
  35.     } else                    /* watch out! */
  36. #endif
  37.     while(bp != NULLBUF){
  38.         if(bp->cnt != 0)
  39.             fwrite(bp->data,1,(unsigned)bp->cnt,ftp->fp);
  40.         bp = free_mbuf(bp);
  41.     }
  42.     if(ftp->fp != stdout && ferror(ftp->fp)){ /* write error in file (disk full?) */
  43.         fclose(ftp->fp);
  44.         ftp->fp = NULLFILE;
  45.         close_self(tcb,RESET);
  46.         if (ftp->username != NULLCHAR)    /* is this a server? */
  47.             tprintf(ftp->control,"452 Disk full or write error\r\n");
  48.     }
  49. }
  50. /* FTP Data channel Transmit upcall handler */
  51. void
  52. ftpdt(tcb,cnt)
  53. struct tcb *tcb;
  54. int16 cnt;
  55. {
  56.     struct ftp *ftp;
  57.     struct mbuf *bp;
  58.     register char *cp;
  59.     register int c;
  60.     int eof_flag;
  61.  
  62.     ftp = (struct ftp *)tcb->user;
  63.     if(ftp->state != SENDING_STATE){
  64.         close_tcp(tcb);
  65.         return;
  66.     }
  67.     if(ftp->type == ASCII_TYPE)
  68.         cnt++;
  69.     while((bp = alloc_mbuf(cnt)) == NULLBUF){
  70.         if ((cnt /= 2) == 0)
  71.             /* Hard to know what to do here */
  72.             return;
  73.     }
  74.     eof_flag = 0;
  75.     if(ftp->type == IMAGE_TYPE){
  76.         bp->cnt = fread(bp->data,1,cnt,ftp->fp);
  77.         if(bp->cnt != cnt)
  78.             eof_flag = 1;
  79.     } else {
  80.         cp = bp->data;
  81.         while(cnt > 1){
  82.             if((c = getc(ftp->fp)) == EOF){
  83.                 eof_flag=1;
  84.                 break;
  85.             }
  86. #if (defined(CPM) || defined(MSDOS))
  87.             /* ^Z is CP/M's text EOF marker, and it is sometimes used
  88.              * by MS-DOS editors too
  89.              */
  90.             if(c == CTLZ){
  91.                 eof_flag = 1;
  92.                 break;
  93.             }
  94. #endif
  95. #if (defined(UNIX) || defined(MAC) || defined(AMIGA) || defined(ATARI_ST) || defined(MSC))
  96.             if(c == '\n'){
  97.                 *cp++ = '\r';
  98.                 bp->cnt++;
  99.                 cnt--;
  100.             }
  101. #endif
  102.             *cp++ = c;
  103.             bp->cnt++;
  104.             cnt--;
  105.         }
  106.     }
  107.     if(bp->cnt != 0)
  108.         send_tcp(tcb,bp);
  109.     else
  110.         free_p(bp);
  111.  
  112.     if(eof_flag){    /* EOF seen */
  113.         fclose(ftp->fp);
  114.         ftp->fp = NULLFILE;
  115.         close_tcp(tcb);
  116.     }
  117. }
  118. /* Allocate an FTP control block */
  119. struct ftp *
  120. ftp_create(bufsize)
  121. unsigned bufsize;
  122. {
  123.     void ftp_delete();
  124.     register struct ftp *ftp;
  125.  
  126.     if((ftp = (struct ftp *)calloc(1,sizeof (struct ftp))) == NULLFTP)
  127.         return NULLFTP;
  128.     if(bufsize != 0 && (ftp->buf = malloc(bufsize)) == NULLCHAR){
  129.         ftp_delete(ftp);
  130.         return NULLFTP;
  131.     }
  132.     ftp->state = COMMAND_STATE;
  133.     ftp->type = ASCII_TYPE; /* Default transfer type */
  134.     return ftp;
  135. }
  136. /* Free resources, delete control block */
  137. void
  138. ftp_delete(ftp)
  139. register struct ftp *ftp;
  140. {
  141.     int i;
  142.     void ftp_dellist();
  143.  
  144.     if(ftp->fp != NULLFILE && ftp->fp != stdout)
  145.         fclose(ftp->fp);
  146.     if(ftp->data != NULLTCB)
  147.         del_tcp(ftp->data);
  148.     if(ftp->username != NULLCHAR)
  149.         free(ftp->username);
  150.     for(i = 0; i < MAXPATH; i++)
  151.         if(ftp->path[i] != NULLCHAR)
  152.             free(ftp->path[i]);
  153.     if(ftp->buf != NULLCHAR)
  154.         free(ftp->buf);
  155.     if(ftp->cd != NULLCHAR)
  156.         free(ftp->cd);
  157.     if(ftp->filename != NULLCHAR)
  158.         free(ftp->filename);
  159.     if(ftp->session != NULLSESSION)
  160.         freesession(ftp->session);
  161.     ftp_dellist(ftp);
  162.     stop_timer(&ftp->xfertime);
  163.     free((char *)ftp);
  164. }
  165. /* Delete the list of files */
  166. void
  167. ftp_dellist(ftp)
  168. register struct ftp *ftp;
  169. {
  170.     register struct ftp_list *ftp_list;
  171.  
  172.     while ((ftp_list = ftp->ftp_list) != NULLFTPLIST) {
  173.         ftp->ftp_list = ftp_list->next;
  174.         free(ftp_list);
  175.     }
  176. }
  177.